<?xml version="1.0"?>
<doc>
    <assembly>
        <name>nunit.core.interfaces</name>
    </assembly>
    <members>
        <member name="T:NUnit.Core.Test">
            <summary>
            	Test Class.
            </summary>
        </member>
        <member name="T:NUnit.Core.ITest">
            <summary>
            Common interface supported by all representations
            of a test. Only includes informational fields.
            The Run method is specifically excluded to allow
            for data-only representations of a test.
            </summary>
        </member>
        <member name="M:NUnit.Core.ITest.CountTestCases(NUnit.Core.ITestFilter)">
            <summary>
            Count the test cases that pass a filter. The
            result should match those that would execute
            when passing the same filter to Run.
            </summary>
            <param name="filter">The filter to apply</param>
            <returns>The count of test cases</returns>
        </member>
        <member name="P:NUnit.Core.ITest.TestName">
            <summary>
            Gets the completely specified name of the test
            encapsulated in a TestName object.
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.TestType">
            <summary>
            Gets a string representing the type of test, e.g.: "Test Case"
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.RunState">
            <summary>
            Indicates whether the test can be run using
            the RunState enum.
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.IgnoreReason">
            <summary>
            Reason for not running the test, if applicable
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.TestCount">
            <summary>
            Count of the test cases ( 1 if this is a test case )
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.Categories">
            <summary>
            Categories available for this test
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.Description">
            <summary>
            Return the description field. 
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.Properties">
            <summary>
            Return additional properties of the test
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.IsSuite">
            <summary>
            True if this is a suite
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.Parent">
            <summary>
             Gets the parent test of this test
            </summary>
        </member>
        <member name="P:NUnit.Core.ITest.Tests">
            <summary>
            For a test suite, the child tests or suites
            Null if this is not a test suite
            </summary>
        </member>
        <member name="F:NUnit.Core.Test.testName">
            <summary>
            TestName that identifies this test
            </summary>
        </member>
        <member name="F:NUnit.Core.Test.runState">
            <summary>
            Indicates whether the test should be executed
            </summary>
        </member>
        <member name="F:NUnit.Core.Test.parent">
            <summary>
            Test suite containing this test, or null
            </summary>
        </member>
        <member name="F:NUnit.Core.Test.properties">
            <summary>
            A dictionary of properties, used to add information
            to tests without requiring the class to change.
            </summary>
        </member>
        <member name="M:NUnit.Core.Test.GetCurrentApartment">
            <summary>
            Get the current apartment state of the test
            </summary>
        </member>
        <member name="M:NUnit.Core.Test.#ctor(System.String)">
            <summary>
            Constructs a test given its name
            </summary>
            <param name="name">The name of the test</param>
        </member>
        <member name="M:NUnit.Core.Test.#ctor(System.String,System.String)">
            <summary>
            Constructs a test given the path through the
            test hierarchy to its parent and a name.
            </summary>
            <param name="pathName">The parent tests full name</param>
            <param name="name">The name of the test</param>
        </member>
        <member name="M:NUnit.Core.Test.#ctor(NUnit.Core.TestName)">
            <summary>
            Constructs a test given a TestName object
            </summary>
            <param name="testName">The TestName for this test</param>
        </member>
        <member name="M:NUnit.Core.Test.SetRunnerID(System.Int32,System.Boolean)">
            <summary>
            Sets the runner id of a test and optionally its children
            </summary>
            <param name="runnerID">The runner id to be used</param>
            <param name="recursive">True if all children should get the same id</param>
        </member>
        <member name="M:NUnit.Core.Test.CountTestCases(NUnit.Core.ITestFilter)">
            <summary>
            Gets a count of test cases that would be run using
            the specified filter.
            </summary>
            <param name="filter"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.Test.Run(NUnit.Core.EventListener,NUnit.Core.ITestFilter)">
            <summary>
            Runs the test under a particular filter, sending
            notifications to a listener.
            </summary>
            <param name="listener">An event listener to receive notifications</param>
            <param name="filter">A filter used in running the test</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.Test.CompareTo(System.Object)">
            <summary>
            Compares this test to another test for sorting purposes
            </summary>
            <param name="obj">The other test</param>
            <returns>Value of -1, 0 or +1 depending on whether the current test is less than, equal to or greater than the other test</returns>
        </member>
        <member name="P:NUnit.Core.Test.RequiresThread">
            <summary>
            Return true if the test requires a thread
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.ApartmentState">
            <summary>
            Get the desired apartment state for running the test
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.TestName">
            <summary>
            Gets the TestName of the test
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.TestType">
            <summary>
            Gets a string representing the kind of test
            that this object represents, for use in display.
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.RunState">
            <summary>
            Whether or not the test should be run
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.IgnoreReason">
            <summary>
            Reason for not running the test, if applicable
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.TestCount">
            <summary>
            Gets a count of test cases represented by
            or contained under this test.
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Categories">
            <summary>
            Gets a list of categories associated with this test.
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Description">
            <summary>
            Gets a description associated with this test.
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Properties">
            <summary>
            Gets the property dictionary for this test
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.IsSuite">
            <summary>
            Indicates whether this test is a suite
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.NUnit#Core#ITest#Parent">
            <summary>
            Gets the parent test of this test
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Parent">
            <summary>
            Gets the parent as a Test object.
            Used by the core to set the parent.
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Tests">
            <summary>
            Gets this test's child tests
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.FixtureType">
            <summary>
            Gets the Type of the fixture used in running this test
            </summary>
        </member>
        <member name="P:NUnit.Core.Test.Fixture">
            <summary>
            Gets or sets a fixture object for running this test
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.IExtensionHost">
            <summary>
            The IExtensionHost interface is implemented by each
            of NUnit's Extension hosts. Currently, there is
            only one host, which resides in the test domain.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IExtensionHost.GetExtensionPoint(System.String)">
            <summary>
            Return an extension point by name, if present
            </summary>
            <param name="name">The name of the extension point</param>
            <returns>The extension point, if found, otherwise null</returns>
        </member>
        <member name="P:NUnit.Core.Extensibility.IExtensionHost.ExtensionPoints">
            <summary>
            Get a list of the ExtensionPoints provided by this host.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.IExtensionHost.FrameworkRegistry">
            <summary>
            Get an interface to the framework registry
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.IExtensionHost.ExtensionTypes">
            <summary>
            Gets the ExtensionTypes supported by this host
            </summary>
            <returns>An enum indicating the ExtensionTypes supported</returns>
        </member>
        <member name="T:NUnit.Core.PropertyNames">
            <summary>
            The PropertyNames struct lists common property names, which are
            accessed by reflection in the NUnit core. This provides a modicum 
            of type safety as opposed to using the strings directly.
            </summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.ExpectedException">
            <summary>Exception Type expected from a test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.ExpectedExceptionName">
            <summary>FullName of the Exception Type expected from a test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.ExpectedMessage">
            <summary>ExpectedException Message</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.MatchType">
            <summary>ExpectedException MatchType</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Result">
            <summary>Expected return result from test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Description">
            <summary>Description of the test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.TestName">
            <summary>Alternate test name</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Arguments">
            <summary>Arguments for the test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Properties">
            <summary>Properties of the test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Categories">
            <summary>Categories of the test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.CategoryName">
            <summary>Name of a category</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.Reason">
            <summary>Reason for not running a test</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.IgnoreExcluded">
            <summary>Flag indicating excluded test should be marked as Ignored</summary>
        </member>
        <member name="F:NUnit.Core.PropertyNames.RequiredAddin">
            <summary>Name of an addin that must be present to run a test</summary>
        </member>
        <member name="T:NUnit.Core.ResultState">
            <summary>
            The ResultState enum indicates the result of running a test
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Inconclusive">
            <summary>
            The result is inconclusive
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.NotRunnable">
            <summary>
            The test was not runnable.
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Skipped">
            <summary>
            The test has been skipped. 
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Ignored">
            <summary>
            The test has been ignored.
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Success">
            <summary>
            The test succeeded
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Failure">
            <summary>
            The test failed
            </summary>
        </member>
        <member name="F:NUnit.Core.ResultState.Error">
            <summary>
            The test encountered an unexpected exception
            </summary>
        </member>
        <member name="T:NUnit.Core.FailureSite">
            <summary>
            The FailureSite enum indicates the stage of a test
            in which an error or failure occured.
            </summary>
        </member>
        <member name="F:NUnit.Core.FailureSite.Test">
            <summary>
            Failure in the test itself
            </summary>
        </member>
        <member name="F:NUnit.Core.FailureSite.SetUp">
            <summary>
            Failure in the SetUp method
            </summary>
        </member>
        <member name="F:NUnit.Core.FailureSite.TearDown">
            <summary>
            Failure in the TearDown method
            </summary>
        </member>
        <member name="F:NUnit.Core.FailureSite.Parent">
            <summary>
            Failure of a parent test
            </summary>
        </member>
        <member name="F:NUnit.Core.FailureSite.Child">
            <summary>
            Failure of a child test
            </summary>
        </member>
        <member name="T:NUnit.Core.Filters.SimpleNameFilter">
            <summary>
            SimpleName filter selects tests based on their name
            </summary>
        </member>
        <member name="T:NUnit.Core.TestFilter">
            <summary>
            Interface to be implemented by filters applied to tests.
            The filter applies when running the test, after it has been
            loaded, since this is the only time an ITest exists.
            </summary>
        </member>
        <member name="T:NUnit.Core.ITestFilter">
            <summary>
            Interface to be implemented by filters applied to tests.
            The filter applies when running the test, after it has been
            loaded, since this is the only time an ITest exists.
            </summary>
        </member>
        <member name="M:NUnit.Core.ITestFilter.Pass(NUnit.Core.ITest)">
            <summary>
            Determine if a particular test passes the filter criteria. Pass
            may examine the parents and/or descendants of a test, depending
            on the semantics of the particular filter
            </summary>
            <param name="test">The test to which the filter is applied</param>
            <returns>True if the test passes the filter, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.ITestFilter.Match(NUnit.Core.ITest)">
            <summary>
            Determine whether the test itself matches the filter criteria,
            without examining either parents or descendants.
            </summary>
            <param name="test">The test to which the filter is applied</param>
            <returns>True if the filter matches the any parent of the test</returns>
        </member>
        <member name="P:NUnit.Core.ITestFilter.IsEmpty">
            <summary>
            Indicates whether this is the EmptyFilter
            </summary>
        </member>
        <member name="F:NUnit.Core.TestFilter.Empty">
            <summary>
            Unique Empty filter.
            </summary>
        </member>
        <member name="M:NUnit.Core.TestFilter.Pass(NUnit.Core.ITest)">
            <summary>
            Determine if a particular test passes the filter criteria. The default 
            implementation checks the test itself, its parents and any descendants.
            
            Derived classes may override this method or any of the Match methods
            to change the behavior of the filter.
            </summary>
            <param name="test">The test to which the filter is applied</param>
            <returns>True if the test passes the filter, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.TestFilter.Match(NUnit.Core.ITest)">
            <summary>
            Determine whether the test itself matches the filter criteria, without
            examining either parents or descendants.
            </summary>
            <param name="test">The test to which the filter is applied</param>
            <returns>True if the filter matches the any parent of the test</returns>
        </member>
        <member name="M:NUnit.Core.TestFilter.MatchParent(NUnit.Core.ITest)">
            <summary>
            Determine whether any ancestor of the test mateches the filter criteria
            </summary>
            <param name="test">The test to which the filter is applied</param>
            <returns>True if the filter matches the an ancestor of the test</returns>
        </member>
        <member name="M:NUnit.Core.TestFilter.MatchDescendant(NUnit.Core.ITest)">
            <summary>
            Determine whether any descendant of the test matches the filter criteria.
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if at least one descendant matches the filter criteria</returns>
        </member>
        <member name="P:NUnit.Core.TestFilter.IsEmpty">
            <summary>
            Indicates whether this is the EmptyFilter
            </summary>
        </member>
        <member name="T:NUnit.Core.TestFilter.EmptyFilter">
            <summary>
            Nested class provides an empty filter - one that always
            returns true when called, unless the test is marked explicit.
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.SimpleNameFilter.#ctor">
            <summary>
            Construct an empty SimpleNameFilter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.SimpleNameFilter.#ctor(System.String)">
            <summary>
            Construct a SimpleNameFilter for a single name
            </summary>
            <param name="name">The name the filter will recognize</param>
        </member>
        <member name="M:NUnit.Core.Filters.SimpleNameFilter.Add(System.String)">
            <summary>
            Add a name to a SimpleNameFilter
            </summary>
            <param name="name">The name to be added</param>
        </member>
        <member name="M:NUnit.Core.Filters.SimpleNameFilter.Match(NUnit.Core.ITest)">
            <summary>
            Check whether the filter matches a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if it matches, otherwise false</returns>
        </member>
        <member name="T:NUnit.Core.Extensibility.IExtensionPoint">
            <summary>
            Represents a single point of extension for NUnit. Some extension
            points may accept only a single extension, while others may
            accept more than one at the same time.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IExtensionPoint.Install(System.Object)">
            <summary>
            Install an extension at this extension point. If the
            extension object does not meet the requirements for
            this extension point, an exception is thrown.
            </summary>
            <param name="extension">The extension to install</param>
        </member>
        <member name="M:NUnit.Core.Extensibility.IExtensionPoint.Remove(System.Object)">
            <summary>
            Removes an extension from this extension point. If the
            extension object is not present, the method returns
            without error.
            </summary>
            <param name="extension"></param>
        </member>
        <member name="P:NUnit.Core.Extensibility.IExtensionPoint.Name">
            <summary>
            Get the name of this extension point
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.IExtensionPoint.Host">
            <summary>
            Get the host that provides this extension point
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.IExtensionPoint2">
            <summary>
            Represents a single point of extension for NUnit. Some extension
            points may accept only a single extension, while others may
            accept more than one at the same time. This interface enhances
            IExtensionPoint by allowing specification of a priority
            order for applying addins.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IExtensionPoint2.Install(System.Object,System.Int32)">
            <summary>
            Install an extension at this extension point specifying
            an integer priority value for the extension.If the
            extension object does not meet the requirements for
            this extension point, or if the extension point does
            not support the requested priority level, an exception 
            is thrown.
            </summary>
            <param name="extension">The extension to install</param>
            <param name="priority">The priority level for this extension</param>
        </member>
        <member name="T:NUnit.Framework.ITestCaseData">
            <summary>
            The ITestCaseData interface is implemented by a class
            that is able to return complete testcases for use by
            a parameterized test method.
            
            NOTE: This interface is used in both the framework
            and the core, even though that results in two different
            types. However, sharing the source code guarantees that
            the various implementations will be compatible and that
            the core is able to reflect successfully over the
            framework implementations of ITestCaseData.
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.Arguments">
            <summary>
            Gets the argument list to be provided to the test
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.Result">
            <summary>
            Gets the expected result
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.ExpectedException">
            <summary>
             Gets the expected exception Type
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName">
            <summary>
            Gets the FullName of the expected exception
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.TestName">
            <summary>
            Gets the name to be used for the test
            </summary>
        </member>
        <member name="P:NUnit.Framework.ITestCaseData.Description">
            <summary>
            Gets the description of the test
            </summary>
        </member>
        <member name="T:NUnit.Core.TestResult">
            <summary>
            The TestResult class represents
            the result of a test and is used to
            communicate results across AppDomains.
            </summary>
            
        </member>
        <member name="F:NUnit.Core.TestResult.resultState">
            <summary>
            Indicates the result of the test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.failureSite">
            <summary>
            Indicates the location of a failure
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.time">
            <summary>
            The elapsed time for executing this test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.test">
            <summary>
            The test that this result pertains to
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.stackTrace">
            <summary>
            The stacktrace at the point of failure
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.message">
            <summary>
            Message giving the reason for failure
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.results">
            <summary>
            List of child results
            </summary>
        </member>
        <member name="F:NUnit.Core.TestResult.assertCount">
            <summary>
            Number of asserts executed by this test
            </summary>
        </member>
        <member name="M:NUnit.Core.TestResult.#ctor(NUnit.Core.TestInfo)">
            <summary>
            Construct a test result given a TestInfo
            </summary>
            <param name="test">The test to be used</param>
        </member>
        <member name="M:NUnit.Core.TestResult.#ctor(NUnit.Core.ITest)">
            <summary>
            Construct a TestResult given an ITest
            </summary>
            <param name="test"></param>
        </member>
        <member name="M:NUnit.Core.TestResult.#ctor(NUnit.Core.TestName)">
            <summary>
            Construct a TestResult given a TestName
            </summary>
            <param name="testName">A TestName</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Success">
            <summary>
            Mark the test as succeeding
            </summary>
        </member>
        <member name="M:NUnit.Core.TestResult.Success(System.String)">
            <summary>
            Mark the test as succeeding and set a message
            </summary>
        </member>
        <member name="M:NUnit.Core.TestResult.Ignore(System.String)">
            <summary>
            Mark the test as ignored.
            </summary>
            <param name="reason">The reason the test was not run</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Ignore(System.Exception)">
            <summary>
            Mark the test as ignored.
            </summary>
            <param name="ex">The ignore exception that was thrown</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Ignore(System.String,System.String)">
            <summary>
            Mark the test as ignored.
            </summary>
            <param name="reason">The reason the test was not run</param>
            <param name="stackTrace">Stack trace giving the location of the command</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Skip(System.String)">
            <summary>
            Mark the test as skipped.
            </summary>
            <param name="reason">The reason the test was not run</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Invalid(System.String)">
            <summary>
            Mark the test a not runnable with a reason
            </summary>
            <param name="reason">The reason the test is invalid</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Invalid(System.Exception)">
            <summary>
            Mark the test as not runnable due to a builder exception
            </summary>
            <param name="ex">The exception thrown by the builder or an addin</param>
        </member>
        <member name="M:NUnit.Core.TestResult.SetResult(NUnit.Core.ResultState,System.String,System.String)">
            <summary>
            Set the result of the test
            </summary>
            <param name="resultState">The ResultState to use in the result</param>
            <param name="reason">The reason the test was not run</param>
            <param name="stackTrace">Stack trace giving the location of the command</param>
        </member>
        <member name="M:NUnit.Core.TestResult.SetResult(NUnit.Core.ResultState,System.Exception)">
            <summary>
            Set the result of the test.
            </summary>
            <param name="resultState">The ResultState to use in the result</param>
            <param name="ex">The exception that caused this result</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Failure(System.String,System.String)">
            <summary>
            Mark the test as a failure due to an
            assertion having failed.
            </summary>
            <param name="message">Message to display</param>
            <param name="stackTrace">Stack trace giving the location of the failure</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Failure(System.String,System.String,NUnit.Core.FailureSite)">
            <summary>
            Mark the test as a failure due to an
            assertion having failed.
            </summary>
            <param name="message">Message to display</param>
            <param name="stackTrace">Stack trace giving the location of the failure</param>
            <param name="failureSite">The site of the failure</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Error(System.Exception)">
            <summary>
            Marks the result as an error due to an exception thrown
            by the test.
            </summary>
            <param name="exception">The exception that was caught</param>
        </member>
        <member name="M:NUnit.Core.TestResult.Error(System.Exception,NUnit.Core.FailureSite)">
            <summary>
            Marks the result as an error due to an exception thrown
            from the indicated FailureSite.
            </summary>
            <param name="exception">The exception that was caught</param>
            <param name="failureSite">The site from which it was thrown</param>
        </member>
        <member name="M:NUnit.Core.TestResult.AddResult(NUnit.Core.TestResult)">
            <summary>
            Add a child result
            </summary>
            <param name="result">The child result to be added</param>
        </member>
        <member name="P:NUnit.Core.TestResult.ResultState">
            <summary>
            Gets the ResultState of the test result, which 
            indicates the success or failure of the test.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.FailureSite">
            <summary>
            Gets the stage of the test in which a failure
            or error occured.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Executed">
            <summary>
            Indicates whether the test executed
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Name">
            <summary>
            Gets the name of the test result
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.FullName">
            <summary>
            Gets the full name of the test result
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Test">
            <summary>
            Gets the test associated with this result
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.IsSuccess">
            <summary>
            Indicates whether the test ran successfully
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.IsFailure">
            <summary>
            Indicates whether the test failed
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.IsError">
            <summary>
            Indicates whether the test had an error (as opposed to a failure)
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Description">
            <summary>
            Gets a description associated with the test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Time">
            <summary>
            Gets the elapsed time for running the test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Message">
            <summary>
            Gets the message associated with a test
            failure or with not running the test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.StackTrace">
            <summary>
            Gets any stacktrace associated with an
            error or failure.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.AssertCount">
            <summary>
            Gets or sets the count of asserts executed
            when running the test.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.HasResults">
            <summary>
            Return true if this result has any child results
            </summary>
        </member>
        <member name="P:NUnit.Core.TestResult.Results">
            <summary>
            Gets a list of the child results of this TestResult
            </summary>
        </member>
        <member name="T:NUnit.Core.Filters.NameFilter">
            <summary>
            Summary description for NameFilter.
            </summary>
            
        </member>
        <member name="M:NUnit.Core.Filters.NameFilter.#ctor">
            <summary>
            Construct an empty NameFilter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.NameFilter.#ctor(NUnit.Core.TestName)">
            <summary>
            Construct a NameFilter for a single TestName
            </summary>
            <param name="testName"></param>
        </member>
        <member name="M:NUnit.Core.Filters.NameFilter.Add(NUnit.Core.TestName)">
            <summary>
            Add a TestName to a NameFilter
            </summary>
            <param name="testName"></param>
        </member>
        <member name="M:NUnit.Core.Filters.NameFilter.Match(NUnit.Core.ITest)">
            <summary>
            Check if a test matches the filter
            </summary>
            <param name="test">The test to match</param>
            <returns>True if it matches, false if not</returns>
        </member>
        <member name="T:NUnit.Core.Filters.AndFilter">
            <summary>
            Combines multiple filters so that a test must pass all 
            of them in order to pass this filter.
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.AndFilter.#ctor">
            <summary>
            Constructs an empty AndFilter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.AndFilter.#ctor(NUnit.Core.ITestFilter[])">
            <summary>
            Constructs an AndFilter from an array of filters
            </summary>
            <param name="filters"></param>
        </member>
        <member name="M:NUnit.Core.Filters.AndFilter.Add(NUnit.Core.ITestFilter)">
            <summary>
            Adds a filter to the list of filters
            </summary>
            <param name="filter">The filter to be added</param>
        </member>
        <member name="M:NUnit.Core.Filters.AndFilter.Pass(NUnit.Core.ITest)">
            <summary>
            Checks whether the AndFilter is matched by a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if all the component filters pass, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.Filters.AndFilter.Match(NUnit.Core.ITest)">
            <summary>
            Checks whether the AndFilter is matched by a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if all the component filters match, otherwise false</returns>
        </member>
        <member name="P:NUnit.Core.Filters.AndFilter.Filters">
            <summary>
            Return an array of the composing filters
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.Addin">
            <summary>
            The Addin class holds information about an addin.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.Addin.#ctor(System.Type)">
            <summary>
            Construct an Addin for a type.
            </summary>
            <param name="type">The type to be used</param>
        </member>
        <member name="M:NUnit.Core.Extensibility.Addin.Equals(System.Object)">
            <summary>
            Return true if two Addins have teh same type name
            </summary>
            <param name="obj">The other addin to be compared</param>
        </member>
        <member name="M:NUnit.Core.Extensibility.Addin.GetHashCode">
            <summary>
            Return a hash code for this addin
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.Name">
            <summary>
            The name of the Addin
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.Description">
            <summary>
            Brief description of what the Addin does
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.ExtensionType">
            <summary>
            The type or types of extension provided, using 
            one or more members of the ExtensionType enumeration.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.TypeName">
            <summary>
            The AssemblyQualifiedName of the type that implements
            the addin.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.Status">
            <summary>
            The status of the addin
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.Addin.Message">
            <summary>
            Any message that clarifies the status of the Addin,
            such as an error message or an explanation of why
            the addin is disabled.
            </summary>
        </member>
        <member name="T:NUnit.Core.IAgency">
            <summary>
            The IAgency interface is implemented by a TestAgency in 
            order to allow TestAgents to register with it.
            </summary>
        </member>
        <member name="M:NUnit.Core.IAgency.Register(NUnit.Core.TestAgent)">
            <summary>
            Registers an agent with an agency
            </summary>
            <param name="agent"></param>
        </member>
        <member name="T:NUnit.Core.Filters.NotFilter">
            <summary>
            NotFilter negates the operation of another filter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.NotFilter.#ctor(NUnit.Core.ITestFilter)">
            <summary>
            Construct a not filter on another filter
            </summary>
            <param name="baseFilter">The filter to be negated</param>
        </member>
        <member name="M:NUnit.Core.Filters.NotFilter.Match(NUnit.Core.ITest)">
            <summary>
            Check whether the filter matches a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if it matches, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.Filters.NotFilter.MatchDescendant(NUnit.Core.ITest)">
            <summary>
            Determine whether any descendant of the test matches the filter criteria.
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if at least one descendant matches the filter criteria</returns>
        </member>
        <member name="P:NUnit.Core.Filters.NotFilter.BaseFilter">
            <summary>
            Gets the base filter
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.ITestCaseBuilder">
            <summary>
            The ITestCaseBuilder interface is exposed by a class that knows how to
            build a test case from certain methods. 
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseBuilder.CanBuildFrom(System.Reflection.MethodInfo)">
            <summary>
            Examine the method and determine if it is suitable for
            this builder to use in building a TestCase.
            
            Note that returning false will cause the method to be ignored 
            in loading the tests. If it is desired to load the method
            but label it as non-runnable, ignored, etc., then this
            method must return true.
            </summary>
            <param name="method">The test method to examine</param>
            <returns>True is the builder can use this method</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseBuilder.BuildFrom(System.Reflection.MethodInfo)">
            <summary>
            Build a TestCase from the provided MethodInfo.
            </summary>
            <param name="method">The method to be used as a test case</param>
            <returns>A TestCase or null</returns>
        </member>
        <member name="T:NUnit.Core.Extensibility.ITestCaseBuilder2">
            <summary>
            ITestCaseBuilder2 extends ITestCaseBuilder with methods
            that include the suite for which the test case is being
            built. Test case builders not needing the suite can
            continue to implement ITestCaseBuilder.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseBuilder2.CanBuildFrom(System.Reflection.MethodInfo,NUnit.Core.Test)">
            <summary>
            Examine the method and determine if it is suitable for
            this builder to use in building a TestCase to be
            included in the suite being populated.
            
            Note that returning false will cause the method to be ignored 
            in loading the tests. If it is desired to load the method
            but label it as non-runnable, ignored, etc., then this
            method must return true.
            </summary>
            <param name="method">The test method to examine</param>
            <param name="suite">The suite being populated</param>
            <returns>True is the builder can use this method</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseBuilder2.BuildFrom(System.Reflection.MethodInfo,NUnit.Core.Test)">
            <summary>
            Build a TestCase from the provided MethodInfo for
            inclusion in the suite being constructed.
            </summary>
            <param name="method">The method to be used as a test case</param>
            <param name="suite">The test suite being populated, or null</param>
            <returns>A TestCase or null</returns>
        </member>
        <member name="T:NUnit.Core.Extensibility.IDataPointProvider">
            <summary>
            The ITestCaseProvider interface is used by extensions
            that provide data for a single test parameter.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IDataPointProvider.HasDataFor(System.Reflection.ParameterInfo)">
            <summary>
            Determine whether any data is available for a parameter.
            </summary>
            <param name="parameter">A ParameterInfo representing one
            argument to a parameterized test</param>
            <returns>True if any data is available, otherwise false.</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.IDataPointProvider.GetDataFor(System.Reflection.ParameterInfo)">
            <summary>
            Return an IEnumerable providing data for use with the
            supplied parameter.
            </summary>
            <param name="parameter">A ParameterInfo representing one
            argument to a parameterized test</param>
            <returns>An IEnumerable providing the required data</returns>
        </member>
        <member name="T:NUnit.Core.Extensibility.ExtensionType">
            <summary>
            The ExtensionType enumeration is used to indicate the
            kinds of extensions provided by an Addin. The addin
            is only installed by hosts supporting one of its
            extension types.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.ExtensionType.Core">
            <summary>
            A Core extension is installed by the CoreExtensions
            host in each test domain.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.ExtensionType.Client">
            <summary>
            A Client extension is installed by all clients
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.ExtensionType.Gui">
            <summary>
            A Gui extension is installed by the gui client
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.IFrameworkRegistry">
            <summary>
            The IFrameworkRegistry allows extensions to register new
            frameworks or emulations of other frameworks.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IFrameworkRegistry.Register(System.String,System.String)">
            <summary>
            Register a framework
            </summary>
            <param name="frameworkName">The name of the framework</param>
            <param name="assemblyName">The name of the assembly that the tests reference</param>
        </member>
        <member name="T:NUnit.Core.TestOutput">
            <summary>
            The TestOutput class holds a unit of output from 
            a test to either stdOut or stdErr
            </summary>
        </member>
        <member name="M:NUnit.Core.TestOutput.#ctor(System.String,NUnit.Core.TestOutputType)">
            <summary>
            Construct with text and an ouput destination type
            </summary>
            <param name="text">Text to be output</param>
            <param name="type">Destination of output</param>
        </member>
        <member name="M:NUnit.Core.TestOutput.ToString">
            <summary>
            Return string representation of the object for debugging
            </summary>
            <returns></returns>
        </member>
        <member name="P:NUnit.Core.TestOutput.Text">
            <summary>
            Get the text 
            </summary>
        </member>
        <member name="P:NUnit.Core.TestOutput.Type">
            <summary>
            Get the output type
            </summary>
        </member>
        <member name="T:NUnit.Core.TestOutputType">
            <summary>
            Enum representing the output destination
            It uses combinable flags so that a given
            output control can accept multiple types
            of output. Normally, each individual
            output uses a single flag value.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestOutputType.Out">
            <summary>
            Send output to stdOut
            </summary>
        </member>
        <member name="F:NUnit.Core.TestOutputType.Error">
            <summary>
            Send output to stdErr
            </summary>
        </member>
        <member name="F:NUnit.Core.TestOutputType.Trace">
            <summary>
            Send output to Trace
            </summary>
        </member>
        <member name="F:NUnit.Core.TestOutputType.Log">
            <summary>
            Send output to Log
            </summary>
        </member>
        <member name="T:NUnit.Core.TestID">
            <summary>
            TestID encapsulates a unique identifier for tests. As
            currently implemented, this is an integer and is unique
            within the AppDomain. TestID is one component of a 
            TestName. We use this object, rather than a raw int,
            for two reasons: (1) to hide the implementation so
            it may be changed later if necessary and (2) so that the
            id may be null in a "weak" TestName.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestID.id">
            <summary>
            The int key that distinguishes this test from all others created
            by the same runner.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestID.nextID">
            <summary>
            Static value to seed ids. It's started at 1000 so any
            uninitialized ids will stand out.
            </summary>
        </member>
        <member name="M:NUnit.Core.TestID.#ctor">
            <summary>
            Construct a new TestID
            </summary>
        </member>
        <member name="M:NUnit.Core.TestID.#ctor(System.Int32)">
            <summary>
            Construct a TestID with a given value.
            Used in parsing test names and in order
            to construct an artificial test node for
            aggregating multiple test runners.
            </summary>
            <param name="id"></param>
        </member>
        <member name="M:NUnit.Core.TestID.Parse(System.String)">
            <summary>
            Parse a TestID from it's string representation
            </summary>
            <param name="s"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.Equals(System.Object)">
            <summary>
            Override of Equals method to allow comparison of TestIDs
            </summary>
            <param name="obj"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.GetHashCode">
            <summary>
            Override of GetHashCode for TestIDs
            </summary>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.ToString">
            <summary>
            Override ToString() to display the int id
            </summary>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.op_Equality(NUnit.Core.TestID,NUnit.Core.TestID)">
            <summary>
            Operator == override
            </summary>
            <param name="id1"></param>
            <param name="id2"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.op_Inequality(NUnit.Core.TestID,NUnit.Core.TestID)">
            <summary>
            Operator != override
            </summary>
            <param name="id1"></param>
            <param name="id2"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestID.Clone">
            <summary>
            Clone this TestID
            </summary>
            <returns>An identical TestID</returns>
        </member>
        <member name="T:NUnit.Core.Extensibility.ITestCaseProvider">
            <summary>
            The ITestCaseProvider interface is used by extensions
            that provide data for parameterized tests, along with
            certain flags and other indicators used in the test.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseProvider.HasTestCasesFor(System.Reflection.MethodInfo)">
            <summary>
            Determine whether any test cases are available for a parameterized method.
            </summary>
            <param name="method">A MethodInfo representing a parameterized test</param>
            <returns>True if any cases are available, otherwise false.</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestCaseProvider.GetTestCasesFor(System.Reflection.MethodInfo)">
            <summary>
            Return an IEnumerable providing test cases for use in
            running a paramterized test.
            </summary>
            <param name="method"></param>
            <returns></returns>
        </member>
        <member name="T:NUnit.Core.TestNode">
            <summary>
            TestNode represents a single test or suite in the test hierarchy.
            TestNode holds common info needed about a test and represents a
            single node - either a test or a suite - in the hierarchy of tests.
            
            TestNode extends TestInfo, which holds all the information with
            the exception of the list of child classes. When constructed from
            a Test, TestNodes are always fully populated with child TestNodes.
            
            Like TestInfo, TestNode is purely a data class, and is not able
            to execute tests.
            
            </summary>
        </member>
        <member name="T:NUnit.Core.TestInfo">
            <summary>
            TestInfo holds common info about a test. It represents only
            a single test or a suite and contains no references to other
            tests. Since it is informational only, it can easily be passed
            around using .Net remoting.
            
            TestInfo is used directly in all EventListener events and in
            TestResults. It contains an ID, which can be used by a 
            runner to locate the actual test.
            
            TestInfo also serves as the base class for TestNode, which
            adds hierarchical information and is used in client code to
            maintain a visible image of the structure of the tests.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.testName">
            <summary>
            TestName that identifies this test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.ignoreReason">
            <summary>
            Reason for not running the test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.testCaseCount">
            <summary>
            Number of test cases in this test or suite
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.isSuite">
            <summary>
            True if this is a suite
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.description">
            <summary>
            The test description
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.categories">
            <summary>
            A list of all the categories assigned to a test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestInfo.properties">
            <summary>
            A dictionary of properties, used to add information
            to tests without requiring the class to change.
            </summary>
        </member>
        <member name="M:NUnit.Core.TestInfo.#ctor(NUnit.Core.ITest)">
            <summary>
            Construct from an ITest
            </summary>
            <param name="test">Test from which a TestNode is to be constructed</param>
        </member>
        <member name="M:NUnit.Core.TestInfo.#ctor(NUnit.Core.TestName,NUnit.Core.ITest[])">
            <summary>
            Construct as a parent to multiple tests.
            </summary>
            <param name="testName">The name to use for the new test</param>
            <param name="tests">An array of child tests</param>
        </member>
        <member name="M:NUnit.Core.TestInfo.#ctor(NUnit.Core.TestName)">
            <summary>
            Construct given a test name
            </summary>
            <param name="testName">The TestName for the new test</param>
        </member>
        <member name="M:NUnit.Core.TestInfo.CountTestCases(NUnit.Core.ITestFilter)">
            <summary>
            Counts the test cases that would be run if this
            test were executed using the provided filter.
            </summary>
            <param name="filter">The filter to apply</param>
            <returns>A count of test cases</returns>
        </member>
        <member name="P:NUnit.Core.TestInfo.TestName">
            <summary>
            Gets the completely specified name of the test
            encapsulated in a TestName object.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.TestType">
            <summary>
            Gets a string representing the kind of test this
            object represents for display purposes.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.Description">
            <summary>
            The test description 
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.RunState">
            <summary>
            Gets the RunState for this test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.IgnoreReason">
            <summary>
            The reason for ignoring a test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.TestCount">
            <summary>
            Count of test cases in this test.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.Parent">
            <summary>
             Gets the parent test of this test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.Categories">
            <summary>
            Gets a list of the categories applied to this test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.Tests">
            <summary>
            Gets a list of any child tests
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.IsSuite">
            <summary>
            True if this is a suite, false if a test case
            </summary>
        </member>
        <member name="P:NUnit.Core.TestInfo.Properties">
            <summary>
            Gets the Properties dictionary for this test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestNode.tests">
            <summary>
            For a test suite, the child tests or suites
            Null if this is not a test suite
            </summary>
        </member>
        <member name="M:NUnit.Core.TestNode.#ctor(NUnit.Core.ITest)">
            <summary>
            Construct from an ITest
            </summary>
            <param name="test">Test from which a TestNode is to be constructed</param>
        </member>
        <member name="M:NUnit.Core.TestNode.#ctor(NUnit.Core.TestName,NUnit.Core.ITest[])">
            <summary>
            Construct a TestNode given a TestName and an
            array of child tests.
            </summary>
            <param name="testName">The TestName of the new test</param>
            <param name="tests">An array of tests to be added as children of the new test</param>
        </member>
        <member name="P:NUnit.Core.TestNode.Parent">
            <summary>
            Gets the parent test of the current test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestNode.Tests">
            <summary>
            Array of child tests, null if this is a test case.
            </summary>
        </member>
        <member name="T:NUnit.Core.RunState">
            <summary>
            The RunState enum indicates whether a test
            can be executed. When used on a TestResult
            it may also indicate whether the test has
            been executed. See individual values for
            restrictions on use.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.NotRunnable">
            <summary>
            The test is not runnable.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.Runnable">
            <summary>
            The test is runnable. This value would 
            normally not appear on a TestResult, since
            it would change to Executed.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.Explicit">
            <summary>
            The test can only be run explicitly. Would
            normally not appear on a TestResult, since
            it would change to Executed or Skipped.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.Skipped">
            <summary>
            The test has been skipped. This value may
            appear on a Test when certain attributes
            are used to skip the test.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.Ignored">
            <summary>
            The test has been ignored. May appear on
            a Test, when the IgnoreAttribute is used.
            Appears on a TestResult in that case or
            if the test is dynamically ignored.
            </summary>
        </member>
        <member name="F:NUnit.Core.RunState.Executed">
            <summary>
            The test has been executed. May only
            appear on a TestResult.
            </summary>
        </member>
        <member name="T:NUnit.Core.OSPlatform">
            <summary>
            OSPlatform represents a particular operating system platform
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.UnixPlatformID_Microsoft">
            <summary>
            Platform ID for Unix as defined by Microsoft .NET 2.0 and greater
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.UnixPlatformID_Mono">
            <summary>
            Platform ID for Unix as defined by Mono
            </summary>
        </member>
        <member name="M:NUnit.Core.OSPlatform.#ctor(System.PlatformID,System.Version)">
            <summary>
            Construct from a platform ID and version
            </summary>
        </member>
        <member name="M:NUnit.Core.OSPlatform.#ctor(System.PlatformID,System.Version,NUnit.Core.OSPlatform.ProductType)">
            <summary>
            Construct from a platform ID, version and product type
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.CurrentPlatform">
            <summary>
            Get the OSPlatform under which we are currently running
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.Platform">
            <summary>
            Get the platform ID of this instance
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.Version">
            <summary>
            Get the Version of this instance
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.Product">
            <summary>
            Get the Product Type of this instance
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWindows">
            <summary>
            Return true if this is a windows platform
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsUnix">
            <summary>
            Return true if this is a Unix or Linux platform
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin32S">
            <summary>
            Return true if the platform is Win32S
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin32Windows">
            <summary>
            Return true if the platform is Win32Windows
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin32NT">
            <summary>
             Return true if the platform is Win32NT
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWinCE">
            <summary>
            Return true if the platform is Windows CE
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin95">
            <summary>
            Return true if the platform is Windows 95
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin98">
            <summary>
            Return true if the platform is Windows 98
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWinME">
            <summary>
            Return true if the platform is Windows ME
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsNT3">
            <summary>
            Return true if the platform is NT 3
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsNT4">
            <summary>
            Return true if the platform is NT 4
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsNT5">
            <summary>
            Return true if the platform is NT 5
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin2K">
            <summary>
            Return true if the platform is Windows 2000
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWinXP">
            <summary>
            Return true if the platform is Windows XP
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin2003Server">
            <summary>
            Return true if the platform is Windows 2003 Server
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsNT6">
            <summary>
            Return true if the platform is NT 6
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsVista">
            <summary>
            Return true if the platform is Vista
            </summary>
        </member>
        <member name="P:NUnit.Core.OSPlatform.IsWin2008Server">
            <summary>
            Return true if the platform is Windows 2008 Server
            </summary>
        </member>
        <member name="T:NUnit.Core.OSPlatform.ProductType">
            <summary>
            Product Type Enumeration used for Windows
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.ProductType.Unknown">
            <summary>
            Product type is unknown or unspecified
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.ProductType.WorkStation">
            <summary>
            Product type is Workstation
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.ProductType.DomainController">
            <summary>
            Product type is Domain Controller
            </summary>
        </member>
        <member name="F:NUnit.Core.OSPlatform.ProductType.Server">
            <summary>
            Product type is Server
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.AddinStatus">
            <summary>
            The AddinStatus enum indicates the load status of an addin.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.AddinStatus.Unknown">
            <summary>
            Not known - default
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.AddinStatus.Enabled">
            <summary>
            The addin is enabled but not loaded
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.AddinStatus.Disabled">
            <summary>
            The addin is disabled
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.AddinStatus.Loaded">
            <summary>
            The addin was loaded successfully
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.AddinStatus.Error">
            <summary>
            An error was encountered loading the addin
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.ParameterSet">
            <summary>
            ParameterSet encapsulates method arguments and
            other selected parameters needed for constructing
            a parameterized test case.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.ParameterSet.properties">
            <summary>
            A dictionary of properties, used to add information
            to tests without requiring the class to change.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ParameterSet.#ctor(System.Exception)">
            <summary>
            Construct a non-runnable ParameterSet, specifying
            the provider excetpion that made it invalid.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ParameterSet.#ctor">
            <summary>
            Construct an empty parameter set, which
            defaults to being Runnable.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ParameterSet.FromDataSource(System.Object)">
            <summary>
            Constructs a ParameterSet from another object, accessing properties 
            by reflection. The object must expose at least an Arguments property
            in order for the test to be runnable.
            </summary>
            <param name="source"></param>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.RunState">
            <summary>
            The RunState for this set of parameters.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.NotRunReason">
            <summary>
            The reason for not running the test case
            represented by this ParameterSet
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.ProviderException">
            <summary>
            Holds any exception thrown by the parameter provider
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.Arguments">
            <summary>
            The arguments to be used in running the test,
            which must match the method signature.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.ExpectedException">
            <summary>
            The Type of any exception that is expected.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.ExpectedExceptionName">
            <summary>
            The FullName of any exception that is expected
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.ExpectedMessage">
            <summary>
            The Message of any exception that is expected
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.MatchType">
            <summary>
             Gets or sets the type of match to be performed on the expected message
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.Result">
            <summary>
            The expected result of the test, which
            must match the method return type.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.Description">
            <summary>
            A description to be applied to this test case
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.TestName">
            <summary>
            A name to be used for this test case in lieu
            of the standard generated name containing
            the argument list.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.Categories">
            <summary>
            Gets a list of categories associated with this test.
            </summary>
        </member>
        <member name="P:NUnit.Core.Extensibility.ParameterSet.Properties">
            <summary>
            Gets the property dictionary for this test
            </summary>
        </member>
        <member name="T:NUnit.Core.ProcessModel">
            <summary>
            Represents the manner in which test assemblies are
            distributed across processes.
            </summary>
        </member>
        <member name="F:NUnit.Core.ProcessModel.Default">
            <summary>
            Use the default setting, depending on the runner
            and the nature of the tests to be loaded.
            </summary>
        </member>
        <member name="F:NUnit.Core.ProcessModel.Single">
            <summary>
            Run tests directly in the NUnit process
            </summary>
        </member>
        <member name="F:NUnit.Core.ProcessModel.Separate">
            <summary>
            Run tests in a single separate process
            </summary>
        </member>
        <member name="F:NUnit.Core.ProcessModel.Multiple">
            <summary>
            Run tests in a separate process per assembly
            </summary>
        </member>
        <member name="T:NUnit.Core.DomainUsage">
            <summary>
            Represents the manner in which test assemblies use
            AppDomains to provide isolation
            </summary>
        </member>
        <member name="F:NUnit.Core.DomainUsage.Default">
            <summary>
            Use the default setting, depending on the runner
            and the nature of the tests to be loaded.
            </summary>
        </member>
        <member name="F:NUnit.Core.DomainUsage.None">
            <summary>
            Don't create a test domain - run in the primary AppDomain
            </summary>
        </member>
        <member name="F:NUnit.Core.DomainUsage.Single">
            <summary>
            Run tests in a single separate test domain
            </summary>
        </member>
        <member name="F:NUnit.Core.DomainUsage.Multiple">
            <summary>
            Run tests in a separate domain per assembly
            </summary>
        </member>
        <member name="T:NUnit.Core.TestPackage">
            <summary>
            TestPackage holds information about a set of tests to
            be loaded by a TestRunner. It may represent a single
            assembly or a set of assemblies. It supports selection
            of a single test fixture for loading.
            </summary>
        </member>
        <member name="M:NUnit.Core.TestPackage.#ctor(System.String)">
            <summary>
            Construct a package, specifying the name of the package.
            If the package name is an assembly file type (dll or exe)
            then the resulting package represents a single assembly.
            Otherwise it is a container for multiple assemblies.
            </summary>
            <param name="name">The name of the package</param>
        </member>
        <member name="M:NUnit.Core.TestPackage.#ctor(System.String,System.Collections.IList)">
            <summary>
            Construct a package, specifying the name to be used
            and a list of assemblies.
            </summary>
            <param name="name">The package name, used to name the top-level test node</param>
            <param name="assemblies">The list of assemblies comprising the package</param>
        </member>
        <member name="M:NUnit.Core.TestPackage.GetSetting(System.String,System.Object)">
            <summary>
            Return the value of a setting or a default.
            </summary>
            <param name="name">The name of the setting</param>
            <param name="defaultSetting">The default value</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestPackage.GetSetting(System.String,System.String)">
            <summary>
            Return the value of a string setting or a default.
            </summary>
            <param name="name">The name of the setting</param>
            <param name="defaultSetting">The default value</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestPackage.GetSetting(System.String,System.Boolean)">
            <summary>
            Return the value of a bool setting or a default.
            </summary>
            <param name="name">The name of the setting</param>
            <param name="defaultSetting">The default value</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestPackage.GetSetting(System.String,System.Int32)">
            <summary>
            Return the value of an int setting or a default.
            </summary>
            <param name="name">The name of the setting</param>
            <param name="defaultSetting">The default value</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestPackage.GetSetting(System.String,System.Enum)">
            <summary>
            Return the value of a enum setting or a default.
            </summary>
            <param name="name">The name of the setting</param>
            <param name="defaultSetting">The default value</param>
            <returns></returns>
        </member>
        <member name="P:NUnit.Core.TestPackage.Name">
            <summary>
            Gets the name of the package
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.FullName">
            <summary>
            Gets the full name of the package, which is usually
            the path to the NUnit project used to create the it
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.BasePath">
            <summary>
            The BasePath to be used in loading the assemblies
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.ConfigurationFile">
            <summary>
            The configuration file to be used
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.PrivateBinPath">
            <summary>
            Addditional directories to be probed when loading assemblies
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.AutoBinPath">
            <summary>
            Indicates whether the probing path should be generated
            automatically based on the list of assemblies.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.Assemblies">
            <summary>
            Assemblies to be loaded. At least one must be specified.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.IsSingleAssembly">
            <summary>
            Return true if the package represents a single assembly.
            No root node is displayed in that case.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.TestName">
            <summary>
            Fully qualified name of test to be loaded. If not 
            specified, all the tests in the assemblies are loaded.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestPackage.Settings">
            <summary>
            Gets the dictionary of settings for this TestPackage
            </summary>
        </member>
        <member name="T:NUnit.Core.Filters.CategoryFilter">
            <summary>
            CategoryFilter is able to select or exclude tests
            based on their categories.
            </summary>
            
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.#ctor">
            <summary>
            Construct an empty CategoryFilter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.#ctor(System.String)">
            <summary>
            Construct a CategoryFilter using a single category name
            </summary>
            <param name="name">A category name</param>
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.#ctor(System.String[])">
            <summary>
            Construct a CategoryFilter using an array of category names
            </summary>
            <param name="names">An array of category names</param>
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.AddCategory(System.String)">
            <summary>
            Add a category name to the filter
            </summary>
            <param name="name">A category name</param>
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.Match(NUnit.Core.ITest)">
            <summary>
            Check whether the filter matches a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.Filters.CategoryFilter.ToString">
            <summary>
            Return the string representation of a category filter
            </summary>
            <returns></returns>
        </member>
        <member name="P:NUnit.Core.Filters.CategoryFilter.Categories">
            <summary>
            Gets the list of categories from this filter
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.IAddinRegistry">
            <summary>
            The IAddinRegistry interface allows registering addins
            and retrieving information about them. It is also used
             to record the load status of an addin.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IAddinRegistry.Register(NUnit.Core.Extensibility.Addin)">
            <summary>
            Registers an addin
            </summary>
            <param name="addin">The addin to be registered</param>
        </member>
        <member name="M:NUnit.Core.Extensibility.IAddinRegistry.IsAddinRegistered(System.String)">
            <summary>
            Returns true if an addin of a given name is registered
            </summary>
            <param name="name">The name of the addin</param>
            <returns>True if an addin of that name is registered, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.IAddinRegistry.SetStatus(System.String,NUnit.Core.Extensibility.AddinStatus,System.String)">
            <summary>
             Sets the load status of an addin
            </summary>
            <param name="name">The name of the addin</param>
            <param name="status">The status to be set</param>
            <param name="message">An optional message explaining the status</param>
        </member>
        <member name="P:NUnit.Core.Extensibility.IAddinRegistry.Addins">
            <summary>
            Gets a list of all addins as Addin objects
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.TestFramework">
            <summary>
            Summary description for TestFramework.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.TestFramework.Name">
            <summary>
            The name of the framework
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.TestFramework.AssemblyName">
            <summary>
            The file name of the assembly that defines the framwork
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.TestFramework.#ctor(System.String,System.String)">
            <summary>
            Constructs a TestFramwork object given its name and assembly name.
            </summary>
            <param name="frameworkName"></param>
            <param name="assemblyName"></param>
        </member>
        <member name="T:NUnit.Core.Extensibility.IAddin">
            <summary>
            Add-ins are used to extend NUnti. All add-ins must
            implement the IAddin interface.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.IAddin.Install(NUnit.Core.Extensibility.IExtensionHost)">
            <summary>
            When called, the add-in installs itself into
            the host, if possible. Because NUnit uses separate
            hosts for the client and test domain environments,
            an add-in may be invited to istall itself more than
            once. The add-in is responsible for checking which
            extension points are supported by the host that is
            passed to it and taking the appropriate action.
            </summary>
            <param name="host">The host in which to install the add-in</param>
            <returns>True if the add-in was installed, otehrwise false</returns>
        </member>
        <member name="T:NUnit.Core.TestRunner">
             <summary>
             The TestRunner Interface allows client code, such as the NUnit console and
             gui runners, to load and run tests. This is the lowest level interface generally
             supported for running tests and is implemented by the RemoteTestRunner class in
             the NUnit core as well as by other classes running on the client side.
             
             The Load method is used to load a suite of tests from one or more 
             assemblies, returning a tree of TestNodes to the caller.
             
             The CountTestCases family of methods returns the number of test cases in the
             loaded suite, either in its entirety or by using a filter to count a subset of tests.
             
             The Run family of methods performs a test run synchronously, returning a TestResult
             or TestResult[] to the caller. If provided, an EventListener interface will be 
             notified of significant events in the running of the tests. A filter may be used
             to run a subset of the tests.
            
             BeginRun and EndRun provide a simplified form of the asynchronous invocation
             pattern used in many places within the .NET framework. Because the current
             implementation allows only one run to be in process at a time, an IAsyncResult
             is not used at this time.
             
             Methods to cancel a run and to wait for a run to complete are also provided. The 
             result of the last run may be obtained by querying the TestResult property.
             
             </summary>
        </member>
        <member name="M:NUnit.Core.TestRunner.Load(NUnit.Core.TestPackage)">
            <summary>
            Load the assemblies in a test package
            </summary>
            <param name="package">The test package to be loaded</param>
            <returns>True if the tests were loaded successfully, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.TestRunner.Unload">
            <summary>
            Unload all tests previously loaded
            </summary>
        </member>
        <member name="M:NUnit.Core.TestRunner.CountTestCases(NUnit.Core.ITestFilter)">
            <summary>
            Count Test Cases using a filter
            </summary>
            <param name="filter">The filter to apply</param>
            <returns>The number of test cases found</returns>
        </member>
        <member name="M:NUnit.Core.TestRunner.Run(NUnit.Core.EventListener)">
            <summary>
            Run all loaded tests and return a test result. The test is run synchronously,
            and the listener interface is notified as it progresses.
            </summary>
            <param name="listener">Interface to receive EventListener notifications.</param>
        </member>
        <member name="M:NUnit.Core.TestRunner.Run(NUnit.Core.EventListener,NUnit.Core.ITestFilter)">
            <summary>
            Run selected tests and return a test result. The test is run synchronously,
            and the listener interface is notified as it progresses.
            </summary>
            <param name="listener">Interface to receive EventListener notifications.</param>
            <param name="filter">The filter to apply when running the tests</param>
        </member>
        <member name="M:NUnit.Core.TestRunner.BeginRun(NUnit.Core.EventListener)">
            <summary>
            Start a run of all loaded tests. The tests are run aynchronously and the 
            listener interface is notified as it progresses.
            </summary>
            <param name="listener">Interface to receive EventListener notifications.</param>
        </member>
        <member name="M:NUnit.Core.TestRunner.BeginRun(NUnit.Core.EventListener,NUnit.Core.ITestFilter)">
            <summary>
            Start a run of selected tests. The tests are run aynchronously and the 
            listener interface is notified as it progresses.
            </summary>
            <param name="listener">Interface to receive EventListener notifications.</param>
            <param name="filter">The filter to apply when running the tests</param>
        </member>
        <member name="M:NUnit.Core.TestRunner.EndRun">
            <summary>
            Wait for an asynchronous run to complete and return the result.
            </summary>
            <returns>A TestResult for the entire run</returns>
        </member>
        <member name="M:NUnit.Core.TestRunner.CancelRun">
            <summary>
             Cancel the test run that is in progress. For a synchronous run,
             a client wanting to call this must create a separate run thread.
            </summary>
        </member>
        <member name="M:NUnit.Core.TestRunner.Wait">
            <summary>
            Wait for the test run in progress to complete. For a synchronous run,
            a client wanting to call this must create a separate run thread. In
            particular, a gui client calling this method is likely to hang, since
            events will not be able to invoke methods on the gui thread.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestRunner.ID">
            <summary>
            TestRunners are identified by an ID. So long as there
            is only one test runner or a single chain of test runners,
            the default id of 0 may be used. However, any client that
            creates multiple runners must ensure that each one has a
            unique ID in order to locate and run specific tests.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestRunner.Running">
            <summary>
            IsTestRunning indicates whether a test is in progress. To retrieve the
            results from an asynchronous test run, wait till IsTestRunning is false.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestRunner.AssemblyInfo">
            <summary>
            Returns information about loaded assemblies
            </summary>
        </member>
        <member name="P:NUnit.Core.TestRunner.Test">
            <summary>
            The loaded test, converted to a tree of TestNodes so they can be
            serialized and marshalled to a remote client.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestRunner.TestResult">
            <summary>
            Result of the last test run.
            </summary>
        </member>
        <member name="T:NUnit.Core.TestName">
            <summary>
            TestName encapsulates all info needed to identify and
            locate a test that has been loaded by a runner. It consists
            of a three components: the simple name of the test, an int
            id that is unique to a given tree of tests and an int 
            runner id that identifies the particular runner that
            holds the test instance.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestName.testID">
            <summary>
            ID that uniquely identifies the test
            </summary>
        </member>
        <member name="F:NUnit.Core.TestName.name">
            <summary>
            The simple name of the test, without qualification
            </summary>
        </member>
        <member name="F:NUnit.Core.TestName.fullName">
            <summary>
            The fully qualified name of the test
            </summary>
        </member>
        <member name="M:NUnit.Core.TestName.Parse(System.String)">
            <summary>
            Parse a string representation of a TestName,
            returning a TestName.
            </summary>
            <param name="s">The string to parse</param>
            <returns>A TestName</returns>
        </member>
        <member name="M:NUnit.Core.TestName.Equals(System.Object)">
            <summary>
            Compares two TestNames for equality
            </summary>
            <param name="obj">the other TestID</param>
            <returns>True if the two TestIDs are equal</returns>
        </member>
        <member name="M:NUnit.Core.TestName.GetHashCode">
            <summary>
            Calculates a hashcode for this TestID
            </summary>
            <returns>The hash code.</returns>
        </member>
        <member name="M:NUnit.Core.TestName.ToString">
            <summary>
            Override ToString() to display the UniqueName
            </summary>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestName.op_Equality(NUnit.Core.TestName,NUnit.Core.TestName)">
            <summary>
            Override the == operator
            </summary>
            <param name="name1"></param>
            <param name="name2"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestName.op_Inequality(NUnit.Core.TestName,NUnit.Core.TestName)">
            <summary>
            Override the != operator
            </summary>
            <param name="name1"></param>
            <param name="name2"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestName.Clone">
            <summary>
            Returns a duplicate of this TestName
            </summary>
            <returns></returns>
        </member>
        <member name="P:NUnit.Core.TestName.TestID">
            <summary>
            Gets or sets the TestID that uniquely identifies this test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestName.RunnerID">
            <summary>
            Gets the ID for the runner that created the test from
            the TestID, or returns -1 if the TestID is null.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestName.Name">
            <summary>
            Gets or sets the simple name of the test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestName.FullName">
            <summary>
            Gets or sets the full (qualified) name of the test
            </summary>
        </member>
        <member name="P:NUnit.Core.TestName.UniqueName">
            <summary>
            Get the string representation of this test name, incorporating all
            the components of the name.
            </summary>
        </member>
        <member name="T:NUnit.Core.TestAssemblyInfo">
            <summary>
            TestAssemblyInfo holds information about a loaded test assembly
            </summary>
        </member>
        <member name="M:NUnit.Core.TestAssemblyInfo.#ctor(System.String,System.Version,NUnit.Core.RuntimeFramework,System.Collections.IList)">
            <summary>
            Constructs a TestAssemblyInfo
            </summary>
            <param name="assemblyName">The name of the assembly</param>
            <param name="imageRuntimeVersion">The version of the runtime for which the assembly was built</param>
            <param name="runnerRuntimeFramework">The runtime framework under which the assembly is loaded</param>
            <param name="testFrameworks">A list of test framework useds by the assembly</param>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.Name">
            <summary>
            Gets the name of the assembly
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.ImageRuntimeVersion">
            <summary>
            Gets the runtime version for which the assembly was built
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.RunnerRuntimeFramework">
            <summary>
            Gets the runtime framework under which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.RunnerRuntimeVersion">
            <summary>
            Gets the runtime version under which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.ProcessId">
            <summary>
            The Id of the process in which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.DomainName">
            <summary>
            The friendly name of the AppDomain in which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.ApplicationBase">
            <summary>
            The Application Base of the AppDomain in which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.PrivateBinPath">
            <summary>
            The PrivateBinPath of the AppDomain in which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.ConfigurationFile">
            <summary>
            The ConfigurationFile of the AppDomain in which the assembly is loaded
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.ModuleName">
            <summary>
            The name of the main module of the process in which the assembly is loaded 
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAssemblyInfo.TestFrameworks">
            <summary>
            Gets a list of testframeworks referenced by the assembly
            </summary>
        </member>
        <member name="T:NUnit.Core.TestAgent">
            <summary>
            Abstract base for all types of TestAgents.
            A TestAgent provides services of locating,
            loading and running tests in a particular
            context such as an AppDomain or Process.
            </summary>
        </member>
        <member name="F:NUnit.Core.TestAgent.agency">
            <summary>
            Reference to the TestAgency that controls this agent
            </summary>
        </member>
        <member name="F:NUnit.Core.TestAgent.agentId">
            <summary>
            This agent's assigned id
            </summary>
        </member>
        <member name="M:NUnit.Core.TestAgent.#ctor(System.Guid)">
            <summary>
            Constructs a TestAgent
            </summary>
            <param name="agentId"></param>
        </member>
        <member name="M:NUnit.Core.TestAgent.#ctor(System.Guid,NUnit.Core.IAgency)">
            <summary>
            Consructor used by TestAgency when creating
            an agent.
            </summary>
            <param name="agentId"></param>
            <param name="agency"></param>
        </member>
        <member name="M:NUnit.Core.TestAgent.Start">
            <summary>
            Starts the agent, performing any required initialization
            </summary>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.TestAgent.Stop">
            <summary>
            Stops the agent, releasing any resources
            </summary>
        </member>
        <member name="M:NUnit.Core.TestAgent.CreateRunner(System.Int32)">
            <summary>
             Creates a runner using a given runner id
            </summary>
        </member>
        <member name="M:NUnit.Core.TestAgent.Dispose">
            <summary>
            Dispose is overridden to stop the agent
            </summary>
        </member>
        <member name="M:NUnit.Core.TestAgent.InitializeLifetimeService">
            <summary>
            Overridden to cause object to live indefinitely
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAgent.Agency">
            <summary>
            The TestAgency with which this agent is asssociated,
            or null if the agent is not tied to an agency.
            </summary>
        </member>
        <member name="P:NUnit.Core.TestAgent.Id">
            <summary>
            A Guid that uniquely identifies this agent.
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.ISuiteBuilder">
            <summary>
            The ISuiteBuilder interface is exposed by a class that knows how to
            build a suite from one or more Types. 
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ISuiteBuilder.CanBuildFrom(System.Type)">
            <summary>
            Examine the type and determine if it is suitable for
            this builder to use in building a TestSuite.
            
            Note that returning false will cause the type to be ignored 
            in loading the tests. If it is desired to load the suite
            but label it as non-runnable, ignored, etc., then this
            method must return true.
            </summary>
            <param name="type">The type of the fixture to be used</param>
            <returns>True if the type can be used to build a TestSuite</returns>
        </member>
        <member name="M:NUnit.Core.Extensibility.ISuiteBuilder.BuildFrom(System.Type)">
            <summary>
            Build a TestSuite from type provided.
            </summary>
            <param name="type">The type of the fixture to be used</param>
            <returns>A TestSuite</returns>
        </member>
        <member name="T:NUnit.Core.RuntimeType">
            <summary>
            Enumeration identifying a common language 
            runtime implementation.
            </summary>
        </member>
        <member name="F:NUnit.Core.RuntimeType.Any">
            <summary>Any supported runtime framework</summary>
        </member>
        <member name="F:NUnit.Core.RuntimeType.Net">
            <summary>Microsoft .NET Framework</summary>
        </member>
        <member name="F:NUnit.Core.RuntimeType.NetCF">
            <summary>Microsoft .NET Compact Framework</summary>
        </member>
        <member name="F:NUnit.Core.RuntimeType.SSCLI">
            <summary>Microsoft Shared Source CLI</summary>
        </member>
        <member name="F:NUnit.Core.RuntimeType.Mono">
            <summary>Mono</summary>
        </member>
        <member name="T:NUnit.Core.RuntimeFramework">
            <summary>
            RuntimeFramework represents a particular version
            of a common language runtime implementation.
            </summary>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.Parse(System.String)">
            <summary>
            Parses a string representing a RuntimeFramework.
            The string may be just a RuntimeType name or just
            a Version or a hyphentated RuntimeType-Version or
            a Version prefixed by 'v'.
            </summary>
            <param name="s"></param>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.IsAvailable(NUnit.Core.RuntimeFramework)">
            <summary>
            Returns true if a particular target runtime is available.
            </summary>
            <param name="framework">The framework being sought</param>
            <returns>True if it's available, false if not</returns>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.IsMonoInstalled">
            <summary>
            Determines whether Mono is installed].
            </summary>
            <returns>
            	<c>true</c> if Mono is installed, otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.IsDotNetInstalled(System.Version)">
            <summary>
            Determines whether the specified version of Microsoft .NET is installed.
            </summary>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.GetAvailableFrameworks(NUnit.Core.RuntimeType)">
            <summary>
            Returns an array of all available frameworks of a given type,
            for example, all mono or all .NET frameworks.
            </summary>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.#ctor(NUnit.Core.RuntimeType,System.Version)">
            <summary>
            Construct from a runtime type and version
            </summary>
            <param name="runtime">The runtime type of the framework</param>
            <param name="version">The version of the framework</param>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.DefaultDisplayName(NUnit.Core.RuntimeType,System.Version)">
            <summary>
            Indicates whether the current framework is available on
            this machine.
            </summary>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.ToString">
            <summary>
            Overridden to return the short name of the framework
            </summary>
            <returns></returns>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.Matches(NUnit.Core.RuntimeFramework)">
            <summary>
            Returns true if the current framework matches the
            one supplied as an argument. Two frameworks match
            if their runtime types are the same or either one
            is RuntimeType.Any and all specified version components
            are equal. Negative (i.e. unspecified) version
            components are ignored.
            </summary>
            <param name="other">The RuntimeFramework to be matched.</param>
            <returns>True on match, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.RuntimeFramework.SpecifyBuild">
            <summary>
            If the build number of this instance is not specified, use
            the standard build number for the major and minor version.
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.CurrentFramework">
            <summary>
            Static method to return a RuntimeFramework object
            for the framework that is currently in use.
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.KnownVersions">
            <summary>
            Return an array of well-known framework versions
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.AvailableFrameworks">
            <summary>
            Gets an array of all available frameworks
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.Runtime">
            <summary>
            The type of this runtime framework
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.Version">
            <summary>
            The version of this runtime framework
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.DisplayName">
            <summary>
            Returns the Display name for this framework
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.IsMono">
            <summary>
            Indicates whether the current runtime is Mono
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.IsNet">
            <summary>
            Indicates whether the current runtime is Microsoft .NET
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.IsNetCF">
            <summary>
            Indicates whether the current runtime is the .NET Compact Framework
            </summary>
        </member>
        <member name="P:NUnit.Core.RuntimeFramework.IsSSCLI">
            <summary>
            Indicates whether the current runtime is the Shared Source CLI (Rotor)
            </summary>
        </member>
        <member name="T:NUnit.Core.IService">
            <summary>
            The IService interface is implemented by all Services.
            </summary>
        </member>
        <member name="M:NUnit.Core.IService.InitializeService">
            <summary>
            Initialize the Service
            </summary>
        </member>
        <member name="M:NUnit.Core.IService.UnloadService">
            <summary>
            Do any cleanup needed before terminating the service
            </summary>
        </member>
        <member name="T:NUnit.Core.Filters.OrFilter">
            <summary>
            Combines multiple filters so that a test must pass one 
            of them in order to pass this filter.
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.OrFilter.#ctor">
            <summary>
            Constructs an empty OrFilter
            </summary>
        </member>
        <member name="M:NUnit.Core.Filters.OrFilter.#ctor(NUnit.Core.ITestFilter[])">
            <summary>
            Constructs an AndFilter from an array of filters
            </summary>
            <param name="filters"></param>
        </member>
        <member name="M:NUnit.Core.Filters.OrFilter.Add(NUnit.Core.ITestFilter)">
            <summary>
            Adds a filter to the list of filters
            </summary>
            <param name="filter">The filter to be added</param>
        </member>
        <member name="M:NUnit.Core.Filters.OrFilter.Pass(NUnit.Core.ITest)">
            <summary>
            Checks whether the OrFilter is matched by a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if any of the component filters pass, otherwise false</returns>
        </member>
        <member name="M:NUnit.Core.Filters.OrFilter.Match(NUnit.Core.ITest)">
            <summary>
            Checks whether the OrFilter is matched by a test
            </summary>
            <param name="test">The test to be matched</param>
            <returns>True if any of the component filters match, otherwise false</returns>
        </member>
        <member name="P:NUnit.Core.Filters.OrFilter.Filters">
            <summary>
            Return an array of the composing filters
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.NUnitAddinAttribute">
            <summary>
            NUnitAddinAttribute is used to mark all add-ins. The marked class
            must implement the IAddin interface.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.NUnitAddinAttribute.Name">
            <summary>
            The name of this addin
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.NUnitAddinAttribute.Description">
            <summary>
            A description for the addin
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.NUnitAddinAttribute.Type">
            <summary>
            The type of extension provided
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.NUnitAddinAttribute.#ctor">
            <summary>
            Default Constructor
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.DecoratorPriority">
            <summary>
            DecoratorPriority wraps constants that may be used
            to represent the relative priority of TestDecorators.
            Decorators with a lower priority are applied first
            so that higher priority decorators wrap them.
            
            NOTE: This feature is subject to change.
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.DecoratorPriority.Default">
            <summary>
            The default priority, equivalent to Normal
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.DecoratorPriority.First">
            <summary>
            Priority for Decorators that must apply first 
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.DecoratorPriority.Normal">
            <summary>
            Normal Decorator priority
            </summary>
        </member>
        <member name="F:NUnit.Core.Extensibility.DecoratorPriority.Last">
            <summary>
            Priority for Decorators that must apply last
            </summary>
        </member>
        <member name="T:NUnit.Core.Extensibility.ITestDecorator">
            <summary>
            The ITestDecorator interface is exposed by a class that knows how to
            enhance the functionality of a test case or suite by decorating it.
            </summary>
        </member>
        <member name="M:NUnit.Core.Extensibility.ITestDecorator.Decorate(NUnit.Core.Test,System.Reflection.MemberInfo)">
            <summary>
            Examine the a Test and either return it as is, modify it
            or return a different TestCase.
            </summary>
            <param name="test">The Test to be decorated</param>
            <param name="member">The MethodInfo used to construct the test</param>
            <returns>The resulting Test</returns>
        </member>
        <member name="T:NUnit.Core.EventListener">
            <summary>
            The EventListener interface is used within the NUnit core to receive 
            notifications of significant events while a test is being run. These
            events are propogated to any client, which may choose to convert them
            to .NET events or to use them directly.
            </summary>
        </member>
        <member name="M:NUnit.Core.EventListener.RunStarted(System.String,System.Int32)">
            <summary>
            Called when a test run is starting
            </summary>
            <param name="name">The name of the test being started</param>
            <param name="testCount">The number of test cases under this test</param>
        </member>
        <member name="M:NUnit.Core.EventListener.RunFinished(NUnit.Core.TestResult)">
            <summary>
            Called when a run finishes normally
            </summary>
            <param name="result">The result of the test</param>
        </member>
        <member name="M:NUnit.Core.EventListener.RunFinished(System.Exception)">
            <summary>
            Called when a run is terminated due to an exception
            </summary>
            <param name="exception">Exception that was thrown</param>
        </member>
        <member name="M:NUnit.Core.EventListener.TestStarted(NUnit.Core.TestName)">
            <summary>
            Called when a test case is starting
            </summary>
            <param name="testName">The name of the test case</param>
        </member>
        <member name="M:NUnit.Core.EventListener.TestFinished(NUnit.Core.TestResult)">
            <summary>
            Called when a test case has finished
            </summary>
            <param name="result">The result of the test</param>
        </member>
        <member name="M:NUnit.Core.EventListener.SuiteStarted(NUnit.Core.TestName)">
            <summary>
            Called when a suite is starting
            </summary>
            <param name="testName">The name of the suite</param>
        </member>
        <member name="M:NUnit.Core.EventListener.SuiteFinished(NUnit.Core.TestResult)">
            <summary>
            Called when a suite has finished
            </summary>
            <param name="result">The result of the suite</param>
        </member>
        <member name="M:NUnit.Core.EventListener.UnhandledException(System.Exception)">
            <summary>
            Called when an unhandled exception is detected during
            the execution of a test run.
            </summary>
            <param name="exception">The exception thta was detected</param>
        </member>
        <member name="M:NUnit.Core.EventListener.TestOutput(NUnit.Core.TestOutput)">
            <summary>
            Called when the test direts output to the console.
            </summary>
            <param name="testOutput">A console message</param>
        </member>
    </members>
</doc>
